<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>spGpu library: Vectors and sparse vectors routines</title>

<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css" />

<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<script type="text/javascript">
  $(document).ready(function() { searchBox.OnSelectItem(0); });
</script>

</head>
<body>
<div id="top"><!-- do not remove this div! -->


<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  
  
  <td style="padding-left: 0.5em;">
   <div id="projectname">spGpu library
   &#160;<span id="projectnumber">1.2.1</span>
   </div>
   <div id="projectbrief">spgpu</div>
  </td>
  
  
  
 </tr>
 </tbody>
</table>
</div>

<!-- Generated by Doxygen 1.7.5 -->
<script type="text/javascript">
var searchBox = new SearchBox("searchBox", "search",false,'Search');
</script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="modules.html"><span>Modules</span></a></li>
      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
      <li>
        <div id="MSearchBox" class="MSearchBoxInactive">
        <span class="left">
          <img id="MSearchSelect" src="search/mag_sel.png"
               onmouseover="return searchBox.OnSearchSelectShow()"
               onmouseout="return searchBox.OnSearchSelectHide()"
               alt=""/>
          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)" 
               onblur="searchBox.OnSearchFieldFocus(false)" 
               onkeyup="searchBox.OnSearchFieldChange(event)"/>
          </span><span class="right">
            <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
          </span>
        </div>
      </li>
    </ul>
  </div>
</div>
<div class="header">
  <div class="summary">
<a href="#func-members">Functions</a>  </div>
  <div class="headertitle">
<div class="title">Vectors and sparse vectors routines</div>  </div>
</div>
<div class="contents">
<table class="memberdecls">
<tr><td colspan="2"><h2><a name="func-members"></a>
Functions</h2></td></tr>
<tr><td class="memItemLeft" align="right" valign="top">float&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga100e30f90e73d0f37bf2c4c6ee586e0e">spgpuSdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device float *a, __device float *b)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gab9614ed7490d9ce371c980829529b421">spgpuSmdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, float *y, int n, __device float *a, __device float *b, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">float&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga227d1b65e6d7b2197a7ba1752b447130">spgpuSnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device float *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gaf95813bec602a34fc0a5f9d8575dd94c">spgpuSmnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, float *y, int n, __device float *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga7ccba52ca5c2d171291f2ebe450bae3d">spgpuSscal</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *y, int n, float alpha, __device float *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gacf729c9119e0b25bf40103af77046316">spgpuSaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *z, int n, float beta, __device float *y, float alpha, __device float *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gab584c993c409face5dbb76b11d16d69e">spgpuSmaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *z, int n, float beta, __device float *y, float alpha, __device float *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gac6bc93853063609ffabf0a521a97c0ba">spgpuSaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *z, int n, float alpha, __device float *x, __device float *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gaf1208a4cece9f3f2fbc4d62a20e48552">spgpuSaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *w, int n, float beta, __device float *z, float alpha, __device float *x, __device float *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga284e8fe18c89cc4d3824f898d6fe2df8">spgpuSmaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *z, int n, float alpha, __device float *x, __device float *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gacc2f991a6c5c5c5a82c0037bebb4cd3b">spgpuSmaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *w, int n, float beta, __device float *z, float alpha, __device float *x, __device float *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gad8d6f13cde8896e69a85061afdba5124">spgpuSgath</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device float *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gae9276eefae7e477d241c634524315c23">spgpuSscat</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device float *y, int xNnz, const __device float *xValues, const __device int *xIndices, int xBaseIndex, float beta)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gada68cb31ced62f97f8218b69e39d884d">spgpuDscal</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *y, int n, double alpha, __device double *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga8b448ff8c5671a8df4b41e5b5f789520">spgpuDdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device double *a, __device double *b)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gac4f3d659026c3969f71849881745ed00">spgpuDmdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, double *y, int n, __device double *a, __device double *b, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga85a1476a1a0325401ab00d90f3bee198">spgpuDnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device double *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga281973e8a0a840b969fef51d156040c9">spgpuDmnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, double *y, int n, __device double *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga0a656c5d33ee1fc188e541fd6e7e705d">spgpuDaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *z, int n, double beta, __device double *y, double alpha, __device double *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gaa1b549cb299ce134c6b9e36b7c0bb886">spgpuDmaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *z, int n, double beta, __device double *y, double alpha, __device double *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga08c0ca04f96db238486762caa11e71d5">spgpuDaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *z, int n, double alpha, __device double *x, __device double *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gaef1d8dfbb24d2a8f6fa14ee489ef53df">spgpuDaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *w, int n, double beta, __device double *z, double alpha, __device double *x, __device double *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga20e8944ad2c75071fb33dcbe626301c2">spgpuDmaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *z, int n, double alpha, __device double *x, __device double *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gafe0d8eb2acf6ed40e3bb7926b43b1d11">spgpuDmaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *w, int n, double beta, __device double *z, double alpha, __device double *x, __device double *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga5c6044d6da8409952f68bb5dbb846d0d">spgpuDgath</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device double *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga59acbca89fc31e8f67f3f2e57e08bf3e">spgpuDscat</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device double *y, int xNnz, const __device double *xValues, const __device int *xIndices, int xBaseIndex, double beta)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">cuFloatComplex&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga51a54b8ad3e3661c62354272308b26f9">spgpuCdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device cuFloatComplex *a, __device cuFloatComplex *b)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga663613d44ab615bab25ac88b4c88dc3c">spgpuCmdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, cuFloatComplex *y, int n, __device cuFloatComplex *a, __device cuFloatComplex *b, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">float&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gac194549aefaf2b4f01e68d81be4a9a25">spgpuCnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device cuFloatComplex *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga35365ca7bd1e082fbad912f70b29372a">spgpuCmnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, float *y, int n, __device cuFloatComplex *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gac26a3f48dcfe2104931e209bf6ed62f2">spgpuCscal</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *y, int n, cuFloatComplex alpha, __device cuFloatComplex *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga5c1bf0f207323f9bdd3eea53cc71d873">spgpuCaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *z, int n, cuFloatComplex beta, __device cuFloatComplex *y, cuFloatComplex alpha, __device cuFloatComplex *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga6e7cbbaec031aa45569680eaeb277e8c">spgpuCmaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *z, int n, cuFloatComplex beta, __device cuFloatComplex *y, cuFloatComplex alpha, __device cuFloatComplex *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga3431d81f456df157072e6260180f387e">spgpuCaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *z, int n, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga377d564a6964394354604f9669da8e0d">spgpuCaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *w, int n, cuFloatComplex beta, __device cuFloatComplex *z, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga2c944942eab263113a38ffba4acb5856">spgpuCmaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *z, int n, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gaf3db4d7d6b0dcb39e743258ae4b9ce36">spgpuCmaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *w, int n, cuFloatComplex beta, __device cuFloatComplex *z, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga73637ee982c31868e4772f63cf4b9148">spgpuCgath</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device cuFloatComplex *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gae9608321cb4d020e88a985e32d3615fc">spgpuCscat</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuFloatComplex *y, int xNnz, const __device cuFloatComplex *xValues, const __device int *xIndices, int xBaseIndex, cuFloatComplex beta)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga6820828784462cf90030a79e65928a16">spgpuZscal</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *y, int n, cuDoubleComplex alpha, __device cuDoubleComplex *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">cuDoubleComplex&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga626a4712375d03f126fc249bf772c2f6">spgpuZdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device cuDoubleComplex *a, __device cuDoubleComplex *b)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga425f908c2a007c8d9c5a03649568c17a">spgpuZmdot</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, cuDoubleComplex *y, int n, __device cuDoubleComplex *a, __device cuDoubleComplex *b, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga09804ee8691b73a14ce8aad6885611d4">spgpuZnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, int n, __device cuDoubleComplex *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga20106c5ad96dd75a6f87c4c7040885b4">spgpuZmnrm2</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, double *y, int n, __device cuDoubleComplex *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga2458ce6c6143970f214490f7cfda6b5b">spgpuZaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *z, int n, cuDoubleComplex beta, __device cuDoubleComplex *y, cuDoubleComplex alpha, __device cuDoubleComplex *x)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gadf7c6a3e4367905b2974a3aa4eb20258">spgpuZmaxpby</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *z, int n, cuDoubleComplex beta, __device cuDoubleComplex *y, cuDoubleComplex alpha, __device cuDoubleComplex *x, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga640b7ac571f691bbdb17e7656b0fc966">spgpuZaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *z, int n, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga675d9ab5af10e396d3ef15f4a9a4130a">spgpuZaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *w, int n, cuDoubleComplex beta, __device cuDoubleComplex *z, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga964028659df64bb9d68c428f1f0fd3bf">spgpuZmaxy</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *z, int n, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga89d971117d4de73131e4089d52176efa">spgpuZmaxypbz</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *w, int n, cuDoubleComplex beta, __device cuDoubleComplex *z, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y, int count, int pitch)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#ga640ef02dd3e4ac094d751eef69d9413c">spgpuZgath</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device cuDoubleComplex *y)</td></tr>
<tr><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group__vec_fun.html#gabe33adab8cb1dfd2a1caeb66b371bd49">spgpuZscat</a> (<a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a> handle, __device cuDoubleComplex *y, int xNnz, const __device cuDoubleComplex *xValues, const __device int *xIndices, int xBaseIndex, cuDoubleComplex beta)</td></tr>
</table>
<hr/><h2>Function Documentation</h2>
<a class="anchor" id="ga5c1bf0f207323f9bdd3eea53cc71d873"></a><!-- doxytag: member="vector.h::spgpuCaxpby" ref="ga5c1bf0f207323f9bdd3eea53cc71d873" args="(spgpuHandle_t handle, __device cuFloatComplex *z, int n, cuFloatComplex beta, __device cuFloatComplex *y, cuFloatComplex alpha, __device cuFloatComplex *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex z = beta * y + alpha * x. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga3431d81f456df157072e6260180f387e"></a><!-- doxytag: member="vector.h::spgpuCaxy" ref="ga3431d81f456df157072e6260180f387e" args="(spgpuHandle_t handle, __device cuFloatComplex *z, int n, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex z = alpha * x * y. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the first input vector </td></tr>
    <tr><td class="paramname">y</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga377d564a6964394354604f9669da8e0d"></a><!-- doxytag: member="vector.h::spgpuCaxypbz" ref="ga377d564a6964394354604f9669da8e0d" args="(spgpuHandle_t handle, __device cuFloatComplex *w, int n, cuFloatComplex beta, __device cuFloatComplex *z, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga51a54b8ad3e3661c62354272308b26f9"></a><!-- doxytag: member="vector.h::spgpuCdot" ref="ga51a54b8ad3e3661c62354272308b26f9" args="(spgpuHandle_t handle, int n, __device cuFloatComplex *a, __device cuFloatComplex *b)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">cuFloatComplex spgpuCdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes single precision complex dot product of a and b vectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>The spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vectors length </td></tr>
    <tr><td class="paramname">a</td><td>the first input vector </td></tr>
    <tr><td class="paramname">b</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the dot product </dd></dl>

</div>
</div>
<a class="anchor" id="ga73637ee982c31868e4772f63cf4b9148"></a><!-- doxytag: member="vector.h::spgpuCgath" ref="ga73637ee982c31868e4772f63cf4b9148" args="(spgpuHandle_t handle, __device cuFloatComplex *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device cuFloatComplex *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCgath </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Single precision complex gather from y to sparse(x). Computes the single precision complex gather from y to xValues (using xIndices). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">xValues</td><td>the destination array for gathered values </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to gather </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be gathered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">y</td><td>the source vector (from which the elements will be gathered) </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga6e7cbbaec031aa45569680eaeb277e8c"></a><!-- doxytag: member="vector.h::spgpuCmaxpby" ref="ga6e7cbbaec031aa45569680eaeb277e8c" args="(spgpuHandle_t handle, __device cuFloatComplex *z, int n, cuFloatComplex beta, __device cuFloatComplex *y, cuFloatComplex alpha, __device cuFloatComplex *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCmaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex z = beta * y + alpha * x of x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga2c944942eab263113a38ffba4acb5856"></a><!-- doxytag: member="vector.h::spgpuCmaxy" ref="ga2c944942eab263113a38ffba4acb5856" args="(spgpuHandle_t handle, __device cuFloatComplex *z, int n, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCmaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex z = alpha * x * y for z,x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting multivector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the multivectors </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">y</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gaf3db4d7d6b0dcb39e743258ae4b9ce36"></a><!-- doxytag: member="vector.h::spgpuCmaxypbz" ref="gaf3db4d7d6b0dcb39e743258ae4b9ce36" args="(spgpuHandle_t handle, __device cuFloatComplex *w, int n, cuFloatComplex beta, __device cuFloatComplex *z, cuFloatComplex alpha, __device cuFloatComplex *x, __device cuFloatComplex *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCmaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in w,z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors' pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga663613d44ab615bab25ac88b4c88dc3c"></a><!-- doxytag: member="vector.h::spgpuCmdot" ref="ga663613d44ab615bab25ac88b4c88dc3c" args="(spgpuHandle_t handle, cuFloatComplex *y, int n, __device cuFloatComplex *a, __device cuFloatComplex *b, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCmdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes single precision complex dot product of a and b multivectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the result, made by dot products of every vector couples from the multivectors a and b </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">a</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">b</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in every multivector </td></tr>
    <tr><td class="paramname">pitch</td><td>the pitch, in number of elements, of every multivectors (so the second element of the first vector in a will be a[pitch], the third a[2*pitch], etc.). </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga35365ca7bd1e082fbad912f70b29372a"></a><!-- doxytag: member="vector.h::spgpuCmnrm2" ref="ga35365ca7bd1e082fbad912f70b29372a" args="(spgpuHandle_t handle, float *y, int n, __device cuFloatComplex *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCmnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex Euclidean vector norm for every vector in the multivector x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the array of results </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the x multivector </td></tr>
    <tr><td class="paramname">x</td><td>the input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in x </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivector's pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gac194549aefaf2b4f01e68d81be4a9a25"></a><!-- doxytag: member="vector.h::spgpuCnrm2" ref="gac194549aefaf2b4f01e68d81be4a9a25" args="(spgpuHandle_t handle, int n, __device cuFloatComplex *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">float spgpuCnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex Euclidean vector norm of x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vector's length </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the euclidean vector norm </dd></dl>

</div>
</div>
<a class="anchor" id="gac26a3f48dcfe2104931e209bf6ed62f2"></a><!-- doxytag: member="vector.h::spgpuCscal" ref="gac26a3f48dcfe2104931e209bf6ed62f2" args="(spgpuHandle_t handle, __device cuFloatComplex *y, int n, cuFloatComplex alpha, __device cuFloatComplex *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCscal </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision complex y = alpha * x. y could be exactly x (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gae9608321cb4d020e88a985e32d3615fc"></a><!-- doxytag: member="vector.h::spgpuCscat" ref="gae9608321cb4d020e88a985e32d3615fc" args="(spgpuHandle_t handle, __device cuFloatComplex *y, int xNnz, const __device cuFloatComplex *xValues, const __device int *xIndices, int xBaseIndex, cuFloatComplex beta)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuCscat </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device cuFloatComplex *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuFloatComplex&#160;</td>
          <td class="paramname"><em>beta</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Single precision complex scatter from sparse(x) to y. Computes the single precision complex scatter from xValues to y (using xIndices). The scattered element will be, for i in [0,xNnz), y[xIndices[i]] = beta*y[xIndices[i]] + xValues[i] (to be noted that y values will be multiplied with beta just for scattered values). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the destination vector (to which the elements will be scattered) </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to scatter </td></tr>
    <tr><td class="paramname">xValues</td><td>the source array from which the values will be read </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be scattered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga0a656c5d33ee1fc188e541fd6e7e705d"></a><!-- doxytag: member="vector.h::spgpuDaxpby" ref="ga0a656c5d33ee1fc188e541fd6e7e705d" args="(spgpuHandle_t handle, __device double *z, int n, double beta, __device double *y, double alpha, __device double *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision z = beta * y + alpha * x. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga08c0ca04f96db238486762caa11e71d5"></a><!-- doxytag: member="vector.h::spgpuDaxy" ref="ga08c0ca04f96db238486762caa11e71d5" args="(spgpuHandle_t handle, __device double *z, int n, double alpha, __device double *x, __device double *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision z = alpha * x * y. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the x multivector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gaef1d8dfbb24d2a8f6fa14ee489ef53df"></a><!-- doxytag: member="vector.h::spgpuDaxypbz" ref="gaef1d8dfbb24d2a8f6fa14ee489ef53df" args="(spgpuHandle_t handle, __device double *w, int n, double beta, __device double *z, double alpha, __device double *x, __device double *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga8b448ff8c5671a8df4b41e5b5f789520"></a><!-- doxytag: member="vector.h::spgpuDdot" ref="ga8b448ff8c5671a8df4b41e5b5f789520" args="(spgpuHandle_t handle, int n, __device double *a, __device double *b)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">double spgpuDdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes double precision dot product of a and b vectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>The spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vectors length </td></tr>
    <tr><td class="paramname">a</td><td>the first input vector </td></tr>
    <tr><td class="paramname">b</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the dot product </dd></dl>

</div>
</div>
<a class="anchor" id="ga5c6044d6da8409952f68bb5dbb846d0d"></a><!-- doxytag: member="vector.h::spgpuDgath" ref="ga5c6044d6da8409952f68bb5dbb846d0d" args="(spgpuHandle_t handle, __device double *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device double *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDgath </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device double *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Double precision gather from y to sparse(x). Computes the double precision gather from y to xValues (using xIndices). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">xValues</td><td>the destination array for gathered values </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to gather </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be gathered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">y</td><td>the source vector (from which the elements will be gathered) </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gaa1b549cb299ce134c6b9e36b7c0bb886"></a><!-- doxytag: member="vector.h::spgpuDmaxpby" ref="gaa1b549cb299ce134c6b9e36b7c0bb886" args="(spgpuHandle_t handle, __device double *z, int n, double beta, __device double *y, double alpha, __device double *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDmaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision z = beta * y + alpha * x of x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivector's pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga20e8944ad2c75071fb33dcbe626301c2"></a><!-- doxytag: member="vector.h::spgpuDmaxy" ref="ga20e8944ad2c75071fb33dcbe626301c2" args="(spgpuHandle_t handle, __device double *z, int n, double alpha, __device double *x, __device double *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDmaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision z = alpha * x * y for z,x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting multivector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the multivectors </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">y</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gafe0d8eb2acf6ed40e3bb7926b43b1d11"></a><!-- doxytag: member="vector.h::spgpuDmaxypbz" ref="gafe0d8eb2acf6ed40e3bb7926b43b1d11" args="(spgpuHandle_t handle, __device double *w, int n, double beta, __device double *z, double alpha, __device double *x, __device double *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDmaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in w,z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors' pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gac4f3d659026c3969f71849881745ed00"></a><!-- doxytag: member="vector.h::spgpuDmdot" ref="gac4f3d659026c3969f71849881745ed00" args="(spgpuHandle_t handle, double *y, int n, __device double *a, __device double *b, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDmdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes double precision dot product of a and b multivectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the result, made by dot products of every vector couples from the multivectors a and b </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">a</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">b</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in every multivector </td></tr>
    <tr><td class="paramname">pitch</td><td>the pitch, in number of elements, of every multivectors (so the second element of the first vector in a will be a[pitch], the third a[2*pitch], etc.). </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga281973e8a0a840b969fef51d156040c9"></a><!-- doxytag: member="vector.h::spgpuDmnrm2" ref="ga281973e8a0a840b969fef51d156040c9" args="(spgpuHandle_t handle, double *y, int n, __device double *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDmnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision Euclidean vector norm for every vector in the multivector x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the array of results </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the x multivector </td></tr>
    <tr><td class="paramname">x</td><td>the input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in x </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivector's pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga85a1476a1a0325401ab00d90f3bee198"></a><!-- doxytag: member="vector.h::spgpuDnrm2" ref="ga85a1476a1a0325401ab00d90f3bee198" args="(spgpuHandle_t handle, int n, __device double *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">double spgpuDnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision Euclidean vector norm of x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vector's length </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the euclidean vector norm </dd></dl>

</div>
</div>
<a class="anchor" id="gada68cb31ced62f97f8218b69e39d884d"></a><!-- doxytag: member="vector.h::spgpuDscal" ref="gada68cb31ced62f97f8218b69e39d884d" args="(spgpuHandle_t handle, __device double *y, int n, double alpha, __device double *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDscal </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the Double precision y = alpha * x. y could be exactly x (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga59acbca89fc31e8f67f3f2e57e08bf3e"></a><!-- doxytag: member="vector.h::spgpuDscat" ref="ga59acbca89fc31e8f67f3f2e57e08bf3e" args="(spgpuHandle_t handle, __device double *y, int xNnz, const __device double *xValues, const __device int *xIndices, int xBaseIndex, double beta)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuDscat </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device double *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double&#160;</td>
          <td class="paramname"><em>beta</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Double precision scatter from sparse(x) to y. Computes the single precision scatter from xValues to y (using xIndices). The scattered element will be, for i in [0,xNnz), y[xIndices[i]] = beta*y[xIndices[i]] + xValues[i] (to be noted that y values will be multiplied with beta just for scattered values). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the destination vector (to which the elements will be scattered) </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to scatter </td></tr>
    <tr><td class="paramname">xValues</td><td>the source array from which the values will be read </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be scattered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gacf729c9119e0b25bf40103af77046316"></a><!-- doxytag: member="vector.h::spgpuSaxpby" ref="gacf729c9119e0b25bf40103af77046316" args="(spgpuHandle_t handle, __device float *z, int n, float beta, __device float *y, float alpha, __device float *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision z = beta * y + alpha * x. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gac6bc93853063609ffabf0a521a97c0ba"></a><!-- doxytag: member="vector.h::spgpuSaxy" ref="gac6bc93853063609ffabf0a521a97c0ba" args="(spgpuHandle_t handle, __device float *z, int n, float alpha, __device float *x, __device float *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision z = alpha * x * y. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the first input vector </td></tr>
    <tr><td class="paramname">y</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gaf1208a4cece9f3f2fbc4d62a20e48552"></a><!-- doxytag: member="vector.h::spgpuSaxypbz" ref="gaf1208a4cece9f3f2fbc4d62a20e48552" args="(spgpuHandle_t handle, __device float *w, int n, float beta, __device float *z, float alpha, __device float *x, __device float *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga100e30f90e73d0f37bf2c4c6ee586e0e"></a><!-- doxytag: member="vector.h::spgpuSdot" ref="ga100e30f90e73d0f37bf2c4c6ee586e0e" args="(spgpuHandle_t handle, int n, __device float *a, __device float *b)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">float spgpuSdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes single precision dot product of a and b vectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>The spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vectors length </td></tr>
    <tr><td class="paramname">a</td><td>the first input vector </td></tr>
    <tr><td class="paramname">b</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the dot product </dd></dl>

</div>
</div>
<a class="anchor" id="gad8d6f13cde8896e69a85061afdba5124"></a><!-- doxytag: member="vector.h::spgpuSgath" ref="gad8d6f13cde8896e69a85061afdba5124" args="(spgpuHandle_t handle, __device float *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device float *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSgath </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device float *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Single precision gather from y to sparse(x). Computes the single precision gather from y to xValues (using xIndices). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">xValues</td><td>the destination array for gathered values </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to gather </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be gathered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">y</td><td>the source vector (from which the elements will be gathered) </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gab584c993c409face5dbb76b11d16d69e"></a><!-- doxytag: member="vector.h::spgpuSmaxpby" ref="gab584c993c409face5dbb76b11d16d69e" args="(spgpuHandle_t handle, __device float *z, int n, float beta, __device float *y, float alpha, __device float *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSmaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision z = beta * y + alpha * x of x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga284e8fe18c89cc4d3824f898d6fe2df8"></a><!-- doxytag: member="vector.h::spgpuSmaxy" ref="ga284e8fe18c89cc4d3824f898d6fe2df8" args="(spgpuHandle_t handle, __device float *z, int n, float alpha, __device float *x, __device float *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSmaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision z = alpha * x * y for z,x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting multivector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the multivectors </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">y</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gacc2f991a6c5c5c5a82c0037bebb4cd3b"></a><!-- doxytag: member="vector.h::spgpuSmaxypbz" ref="gacc2f991a6c5c5c5a82c0037bebb4cd3b" args="(spgpuHandle_t handle, __device float *w, int n, float beta, __device float *z, float alpha, __device float *x, __device float *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSmaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in w,z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors' pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gab9614ed7490d9ce371c980829529b421"></a><!-- doxytag: member="vector.h::spgpuSmdot" ref="gab9614ed7490d9ce371c980829529b421" args="(spgpuHandle_t handle, float *y, int n, __device float *a, __device float *b, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSmdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes single precision dot product of a and b multivectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the result, made by dot products of every vector couples from the multivectors a and b </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">a</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">b</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in every multivector </td></tr>
    <tr><td class="paramname">pitch</td><td>the pitch, in number of elements, of every multivectors (so the second element of the first vector in a will be a[pitch], the third a[2*pitch], etc.). </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gaf95813bec602a34fc0a5f9d8575dd94c"></a><!-- doxytag: member="vector.h::spgpuSmnrm2" ref="gaf95813bec602a34fc0a5f9d8575dd94c" args="(spgpuHandle_t handle, float *y, int n, __device float *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSmnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision Euclidean vector norm for every vector in the multivector x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the array of results </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the x multivector </td></tr>
    <tr><td class="paramname">x</td><td>the input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in x </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivector's pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga227d1b65e6d7b2197a7ba1752b447130"></a><!-- doxytag: member="vector.h::spgpuSnrm2" ref="ga227d1b65e6d7b2197a7ba1752b447130" args="(spgpuHandle_t handle, int n, __device float *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">float spgpuSnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision Euclidean vector norm of x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vector's length </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the euclidean vector norm </dd></dl>

</div>
</div>
<a class="anchor" id="ga7ccba52ca5c2d171291f2ebe450bae3d"></a><!-- doxytag: member="vector.h::spgpuSscal" ref="ga7ccba52ca5c2d171291f2ebe450bae3d" args="(spgpuHandle_t handle, __device float *y, int n, float alpha, __device float *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSscal </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the single precision y = alpha * x. y could be exactly x (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gae9276eefae7e477d241c634524315c23"></a><!-- doxytag: member="vector.h::spgpuSscat" ref="gae9276eefae7e477d241c634524315c23" args="(spgpuHandle_t handle, __device float *y, int xNnz, const __device float *xValues, const __device int *xIndices, int xBaseIndex, float beta)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuSscat </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device float *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device float *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>beta</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Single precision scatter from sparse(x) to y. Computes the single precision scatter from xValues to y (using xIndices). The scattered element will be, for i in [0,xNnz), y[xIndices[i]] = beta*y[xIndices[i]] + xValues[i] (to be noted that y values will be multiplied with beta just for scattered values). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the destination vector (to which the elements will be scattered) </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to scatter </td></tr>
    <tr><td class="paramname">xValues</td><td>the source array from which the values will be read </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be scattered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga2458ce6c6143970f214490f7cfda6b5b"></a><!-- doxytag: member="vector.h::spgpuZaxpby" ref="ga2458ce6c6143970f214490f7cfda6b5b" args="(spgpuHandle_t handle, __device cuDoubleComplex *z, int n, cuDoubleComplex beta, __device cuDoubleComplex *y, cuDoubleComplex alpha, __device cuDoubleComplex *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex z = beta * y + alpha * x. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga640b7ac571f691bbdb17e7656b0fc966"></a><!-- doxytag: member="vector.h::spgpuZaxy" ref="ga640b7ac571f691bbdb17e7656b0fc966" args="(spgpuHandle_t handle, __device cuDoubleComplex *z, int n, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex z = alpha * x * y. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the x multivector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga675d9ab5af10e396d3ef15f4a9a4130a"></a><!-- doxytag: member="vector.h::spgpuZaxypbz" ref="ga675d9ab5af10e396d3ef15f4a9a4130a" args="(spgpuHandle_t handle, __device cuDoubleComplex *w, int n, cuDoubleComplex beta, __device cuDoubleComplex *z, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga626a4712375d03f126fc249bf772c2f6"></a><!-- doxytag: member="vector.h::spgpuZdot" ref="ga626a4712375d03f126fc249bf772c2f6" args="(spgpuHandle_t handle, int n, __device cuDoubleComplex *a, __device cuDoubleComplex *b)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">cuDoubleComplex spgpuZdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes double precision complex dot product of a and b vectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>The spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vectors length </td></tr>
    <tr><td class="paramname">a</td><td>the first input vector </td></tr>
    <tr><td class="paramname">b</td><td>the second input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the dot product </dd></dl>

</div>
</div>
<a class="anchor" id="ga640ef02dd3e4ac094d751eef69d9413c"></a><!-- doxytag: member="vector.h::spgpuZgath" ref="ga640ef02dd3e4ac094d751eef69d9413c" args="(spgpuHandle_t handle, __device cuDoubleComplex *xValues, int xNnz, const __device int *xIndices, int xBaseIndex, const __device cuDoubleComplex *y)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZgath </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex gather from y to xValues (using xIndices). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">xValues</td><td>the destination array for gathered values </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to gather </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be gathered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">y</td><td>the source vector (from which the elements will be gathered) </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gadf7c6a3e4367905b2974a3aa4eb20258"></a><!-- doxytag: member="vector.h::spgpuZmaxpby" ref="gadf7c6a3e4367905b2974a3aa4eb20258" args="(spgpuHandle_t handle, __device cuDoubleComplex *z, int n, cuDoubleComplex beta, __device cuDoubleComplex *y, cuDoubleComplex alpha, __device cuDoubleComplex *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZmaxpby </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex z = beta * y + alpha * x of x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">y</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivector's pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga964028659df64bb9d68c428f1f0fd3bf"></a><!-- doxytag: member="vector.h::spgpuZmaxy" ref="ga964028659df64bb9d68c428f1f0fd3bf" args="(spgpuHandle_t handle, __device cuDoubleComplex *z, int n, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZmaxy </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex z = alpha * x * y for z,x and y multivectors. z could be exactly x or y (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">z</td><td>the resulting multivector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the multivectors </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">y</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga89d971117d4de73131e4089d52176efa"></a><!-- doxytag: member="vector.h::spgpuZmaxypbz" ref="ga89d971117d4de73131e4089d52176efa" args="(spgpuHandle_t handle, __device cuDoubleComplex *w, int n, cuDoubleComplex beta, __device cuDoubleComplex *z, cuDoubleComplex alpha, __device cuDoubleComplex *x, __device cuDoubleComplex *y, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZmaxypbz </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>beta</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>z</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex w = beta * z + alpha * x * y. w could be exactly x, y or z (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">w</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
    <tr><td class="paramname">z</td><td>the first input vector </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the second input vector </td></tr>
    <tr><td class="paramname">y</td><td>the third input vector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in w,z,x and y multivectors </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivectors' pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga425f908c2a007c8d9c5a03649568c17a"></a><!-- doxytag: member="vector.h::spgpuZmdot" ref="ga425f908c2a007c8d9c5a03649568c17a" args="(spgpuHandle_t handle, cuDoubleComplex *y, int n, __device cuDoubleComplex *a, __device cuDoubleComplex *b, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZmdot </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes double precision complex dot product of a and b multivectors. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the result, made by dot products of every vector couples from the multivectors a and b </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">a</td><td>the first input multivector </td></tr>
    <tr><td class="paramname">b</td><td>the second input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in every multivector </td></tr>
    <tr><td class="paramname">pitch</td><td>the pitch, in number of elements, of every multivectors (so the second element of the first vector in a will be a[pitch], the third a[2*pitch], etc.). </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga20106c5ad96dd75a6f87c4c7040885b4"></a><!-- doxytag: member="vector.h::spgpuZmnrm2" ref="ga20106c5ad96dd75a6f87c4c7040885b4" args="(spgpuHandle_t handle, double *y, int n, __device cuDoubleComplex *x, int count, int pitch)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZmnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">double *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>pitch</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex Euclidean vector norm for every vector in the multivector x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the array of results </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length in the x multivector </td></tr>
    <tr><td class="paramname">x</td><td>the input multivector </td></tr>
    <tr><td class="paramname">count</td><td>the number of vectors in x </td></tr>
    <tr><td class="paramname">pitch</td><td>the multivector's pitch </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ga09804ee8691b73a14ce8aad6885611d4"></a><!-- doxytag: member="vector.h::spgpuZnrm2" ref="ga09804ee8691b73a14ce8aad6885611d4" args="(spgpuHandle_t handle, int n, __device cuDoubleComplex *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">double spgpuZnrm2 </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex Euclidean vector norm of x. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">n</td><td>the vector's length </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>
<dl class="return"><dt><b>Returns:</b></dt><dd>the euclidean vector norm </dd></dl>

</div>
</div>
<a class="anchor" id="ga6820828784462cf90030a79e65928a16"></a><!-- doxytag: member="vector.h::spgpuZscal" ref="ga6820828784462cf90030a79e65928a16" args="(spgpuHandle_t handle, __device cuDoubleComplex *y, int n, cuDoubleComplex alpha, __device cuDoubleComplex *x)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZscal </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>n</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>alpha</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>x</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex y = alpha * x. y could be exactly x (without offset) or another vector. </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the resulting vector </td></tr>
    <tr><td class="paramname">n</td><td>the vectors' length </td></tr>
    <tr><td class="paramname">alpha</td><td>the alpha value </td></tr>
    <tr><td class="paramname">x</td><td>the input vector </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="gabe33adab8cb1dfd2a1caeb66b371bd49"></a><!-- doxytag: member="vector.h::spgpuZscat" ref="gabe33adab8cb1dfd2a1caeb66b371bd49" args="(spgpuHandle_t handle, __device cuDoubleComplex *y, int xNnz, const __device cuDoubleComplex *xValues, const __device int *xIndices, int xBaseIndex, cuDoubleComplex beta)" -->
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void spgpuZscat </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="group__core_fun.html#ga5d4825ac610d6524df843758da392dec">spgpuHandle_t</a>&#160;</td>
          <td class="paramname"><em>handle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">__device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xNnz</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device cuDoubleComplex *&#160;</td>
          <td class="paramname"><em>xValues</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const __device int *&#160;</td>
          <td class="paramname"><em>xIndices</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>xBaseIndex</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">cuDoubleComplex&#160;</td>
          <td class="paramname"><em>beta</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div>
<div class="memdoc">
<p>Computes the double precision complex scatter from xValues to y (using xIndices). The scattered element will be, for i in [0,xNnz), y[xIndices[i]] = beta*y[xIndices[i]] + xValues[i] (to be noted that y values will be multiplied with beta just for scattered values). </p>
<dl><dt><b>Parameters:</b></dt><dd>
  <table class="params">
    <tr><td class="paramname">handle</td><td>the spgpu handle used to call this routine </td></tr>
    <tr><td class="paramname">y</td><td>the destination vector (to which the elements will be scattered) </td></tr>
    <tr><td class="paramname">xNnz</td><td>the number of elements to scatter </td></tr>
    <tr><td class="paramname">xValues</td><td>the source array from which the values will be read </td></tr>
    <tr><td class="paramname">xIndices</td><td>the array of indices for the elements to be scattered </td></tr>
    <tr><td class="paramname">xBaseIndex</td><td>the base index used in xIndices (i.e. 0 for C, 1 for Fortran). </td></tr>
    <tr><td class="paramname">beta</td><td>the beta value </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
</div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark">&#160;</span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark">&#160;</span>Data Structures</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark">&#160;</span>Variables</a></div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>



<hr class="footer"/><address class="footer"><small>
Generated on Tue Oct 7 2014 23:31:15 for spGpu library by &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/>
</a> 1.7.5
</small></address>

</body>
</html>
